﻿using System.Security;

namespace Isotop.Text
{
	public partial class LazyStringBuilder
	{
		//[SecurityCritical]
		//public unsafe override string ToString()
		//{
		//   /*char[] array = (char[])ChunkCharsField.GetValue(_tempBuilder);
		//   var aLen = _tempBuilder.Length;
		//   if (Length + aLen == 0)
		//   {
		//      Console.WriteLine("Length == 0");
		//      return string.Empty;
		//   }*/
		//   FlushTempBuilder(false);
		//   var output = FastAllocateString(Length);
		//   fixed (char* dst = output)
		//   {
		//      char* curDst = dst;
		//      //if(!_strings.Parts.Skip(4).Any())
		//      //Console.WriteLine("Count: " + _strings.Parts.Count());
		//      foreach (var part in Parts)
		//      //Parallel.ForEach(_strings.Parts, part =>
		//      {
		//         //char* curDst = dstCopy + GetTotalLength(part);
		//         foreach (var item in part.Array)
		//         {
		//            var len = item.Length;
		//            if (item.CharArray != null)
		//            {
		//               fixed (char* src = item.CharArray)
		//                  wstrcpy(curDst, src, item.Length);
		//            }
		//            else
		//            {
		//               fixed (char* src = item.String)
		//                  wstrcpy(curDst, src, item.Length);
		//            }
		//            curDst += len;
		//         }
		//      }
		//      //else
		//      ////);
		//      //Parallel.ForEach(_strings.Parts, part =>
		//      //   {
		//      //      char* curDst = dstCopy + GetTotalLength(part);
		//      //      foreach (var item in part.Array)
		//      //      {
		//      //         var len = item.Length;
		//      //         if (item.CharArray != null)
		//      //         {
		//      //            fixed (char* src = item.CharArray)
		//      //               wstrcpy(curDst, src, item.Length);
		//      //         }
		//      //         else
		//      //         {
		//      //            fixed (char* src = item.String)
		//      //               wstrcpy(curDst, src, item.Length);
		//      //         }
		//      //         curDst += len;
		//      //      }
		//      //   }
		//      //);
		//   }
		//   /*
		//   if (aLen > 0)
		//   {
		//      fixed (char* dst = output)
		//      {
		//         fixed (char* src = array)
		//         {
		//            wstrcpy(dst + curLen, src, aLen);
		//         }
		//      }
		//   }*/
		//   return output;
		//}

		//void UpdateLength()
		//{
		//   _length = _strings.Sum(s => s.Length);
		//}

		//public Span GetSpan(int startIndex, int length)
		//{
		//   Span span;
		//   span.FirstIndex = -1;
		//   span.FirstStartIndex = 0;
		//   span.Length = 0;
		//   span.LastIndex = -1;
		//   span.LastLength = 0;

		//   int curTotLen = 0;
		//   for (int i = 0; i < _strings.Count; i++)
		//   {
		//      int len = _strings[i].Length;
		//      if (span.FirstIndex == -1 && curTotLen + len > startIndex)
		//      {
		//         span.FirstIndex = i;
		//         if (curTotLen < startIndex)
		//            span.FirstStartIndex = curTotLen + len - startIndex;
		//      }
		//      if (span.FirstIndex == i)
		//      {
		//         if (len - span.FirstStartIndex >= length)
		//         {
		//            span.LastIndex = i;
		//            span.Length = span.LastLength = len - span.FirstStartIndex;
		//            break;
		//         }
		//         span.Length = len - span.FirstStartIndex;
		//      }
		//      else if (span.FirstIndex < i && span.FirstIndex >= 0)
		//      {
		//         if (span.Length + len >= length)
		//         {
		//            span.LastIndex = i;
		//            span.LastLength = length - span.Length;
		//            if (span.LastLength == 0)
		//               span.LastLength = len;
		//            span.Length += span.LastLength;
		//            break;
		//         }
		//         span.Length += len;
		//      }
		//      curTotLen += len;
		//   }

		//   if (span.LastIndex == -1)
		//      throw new ArgumentException();

		//   return span;
		//}

		//public class RefFragment
		//{
		//   public int Index;
		//   public int Start;
		//   public int Length;
		//}

		//public struct Span
		//{
		//   public int FirstIndex;
		//   public int FirstStartIndex;
		//   public int LastIndex;
		//   public int LastLength;
		//   public int Length;

		//   public IEnumerable<RefFragment> PartsReverseOrder(List<string> strings)
		//   {
		//      if (FirstIndex == LastIndex)
		//         yield return new RefFragment {Index = FirstIndex, Length = LastLength, Start = FirstIndex};
		//      else
		//      {
		//         yield return new RefFragment { Index = LastIndex, Length = LastLength, Start = 0 };
		//         for(int i = LastIndex - 1; i > FirstIndex; i--)
		//            yield return new RefFragment { Index = i, Length = strings[i].Length, Start = 0 };
		//         yield return new RefFragment { Index = FirstIndex, Length = strings[FirstIndex].Length - FirstStartIndex, Start = FirstStartIndex };
		//      }
		//   }
		//}

		/// <exception cref="ArgumentOutOfRangeException"><c>index</c> is out of range.</exception>
		//[SecuritySafeCritical]
		//public unsafe LazyStringBuilder Insert(string value, int index)
		//{
			//var curLen = 0;
			//if (index > Length)
			//   throw new ArgumentOutOfRangeException("index", "Index must be lower or equal to the length of the StringBuilder");

			//foreach (var part in Parts)
			//{
			//   foreach (var seq in part.Array)
			//   {
			//      if (curLen + seq.Length > index)
			//      {
			//         if (seq.String == null && value.Length + seq.Length < seq.CharArray.Length) // We can fit the string in the char array
			//         {
			//            fixed (char* d = seq.CharArray)
			//            fixed (char* s = value)
			//               wstrcpy(d, s, value.Length);
			//         }
			//         else
			//         {
			//            var newArr = new CharSequence[part.Array.Length + 1];	
			//         }

			//         return this;
			//      }
			//      if (curLen + seq.Length == index)
			//      {

			//      }
			//      curLen += seq.Length;
			//   }
			//}
		//}
	}
}
